package.h

/* createrepo_c - Library of routines for manipulation with repodata
 * Copyright (C) 2012  Tomas Mlcoch
 * Copyright (C) 2007  James Bowes
 * Copyright (C) 2006  Seth Vidal
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 * USA.
 */
 
#ifndef __C_CREATEREPOLIB_PACKAGE_H__
#define __C_CREATEREPOLIB_PACKAGE_H__
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <glib.h>

 
typedef enum {
    CR_PACKAGE_FROM_HEADER  = (1<<1),   
    CR_PACKAGE_FROM_XML     = (1<<2),   
    /* Some values are reserved (for sqlite, solv, etc..) */
    CR_PACKAGE_LOADED_PRI   = (1<<10),  
    CR_PACKAGE_LOADED_FIL   = (1<<11),  
    CR_PACKAGE_LOADED_OTH   = (1<<12),  
    CR_PACKAGE_SINGLE_CHUNK = (1<<13),  
} cr_PackageLoadingFlags;

typedef struct {
    char *name;                 
    char *flags;                
    char *epoch;                
    char *version;              
    char *release;              
    gboolean pre;               
} cr_Dependency;

typedef struct {
    char *type;                 
    char *path;                 
    char *name;                 
    char *digest;               
} cr_PackageFile;

typedef struct {
    char *author;               
    gint64 date;                
    char *changelog;            
} cr_ChangelogEntry;

typedef struct {
    void *data;
    gsize size;
} cr_BinaryData;

typedef struct _cr_Package cr_Package;

cr_Dependency *cr_dependency_new(void);

cr_PackageFile *cr_package_file_new(void);

cr_ChangelogEntry *cr_changelog_entry_new(void);

cr_BinaryData *cr_binary_data_new(void);

cr_Package *cr_package_new(void);

cr_Package *cr_package_new_without_chunk(void);

void cr_package_free(cr_Package *package);

gchar *cr_package_nvra(cr_Package *package);

gchar *cr_package_nevra(cr_Package *package);

cr_Package *cr_package_copy(cr_Package *package);

const char *cr_package_get_pkg_id(cr_Package *package);

void cr_package_set_pkg_id(cr_Package *package, const char *value);

const char *cr_package_get_name(cr_Package *package);

void cr_package_set_name(cr_Package *package, const char *value);

const char *cr_package_get_arch(cr_Package *package);

void cr_package_set_arch(cr_Package *package, const char *value);

const char *cr_package_get_version(cr_Package *package);

void cr_package_set_version(cr_Package *package, const char *value);

const char *cr_package_get_epoch(cr_Package *package);

void cr_package_set_epoch(cr_Package *package, const char *value);

const char *cr_package_get_release(cr_Package *package);

void cr_package_set_release(cr_Package *package, const char *value);

const char *cr_package_get_summary(cr_Package *package);

void cr_package_set_summary(cr_Package *package, const char *value);

const char *cr_package_get_description(cr_Package *package);

void cr_package_set_description(cr_Package *package, const char *value);

const char *cr_package_get_url(cr_Package *package);

void cr_package_set_url(cr_Package *package, const char *value);

const char *cr_package_get_rpm_license(cr_Package *package);

void cr_package_set_rpm_license(cr_Package *package, const char *value);

const char *cr_package_get_rpm_vendor(cr_Package *package);

void cr_package_set_rpm_vendor(cr_Package *package, const char *value);

const char *cr_package_get_rpm_group(cr_Package *package);

void cr_package_set_rpm_group(cr_Package *package, const char *value);

const char *cr_package_get_rpm_buildhost(cr_Package *package);

void cr_package_set_rpm_buildhost(cr_Package *package, const char *value);

const char *cr_package_get_rpm_sourcerpm(cr_Package *package);

void cr_package_set_rpm_sourcerpm(cr_Package *package, const char *value);

const char *cr_package_get_rpm_packager(cr_Package *package);

void cr_package_set_rpm_packager(cr_Package *package, const char *value);

const char *cr_package_get_location_href(cr_Package *package);

void cr_package_set_location_href(cr_Package *package, const char *value);

const char *cr_package_get_location_base(cr_Package *package);

void cr_package_set_location_base(cr_Package *package, const char *value);

const char *cr_package_get_checksum_type(cr_Package *package);

void cr_package_set_checksum_type(cr_Package *package, const char *value);

const char *cr_package_get_files_checksum_type(cr_Package *package);

void cr_package_set_files_checksum_type(cr_Package *package, const char *value);

const char *cr_package_get_hdrid(cr_Package *package);

void cr_package_set_hdrid(cr_Package *package, const char *value);

gint64 cr_package_get_pkg_key(cr_Package *package);

void cr_package_set_pkg_key(cr_Package *package, gint64 value);

gint64 cr_package_get_time_file(cr_Package *package);

void cr_package_set_time_file(cr_Package *package, gint64 value);

gint64 cr_package_get_time_build(cr_Package *package);

void cr_package_set_time_build(cr_Package *package, gint64 value);

gint64 cr_package_get_rpm_header_start(cr_Package *package);

void cr_package_set_rpm_header_start(cr_Package *package, gint64 value);

gint64 cr_package_get_rpm_header_end(cr_Package *package);

void cr_package_set_rpm_header_end(cr_Package *package, gint64 value);

gint64 cr_package_get_size_package(cr_Package *package);

void cr_package_set_size_package(cr_Package *package, gint64 value);

gint64 cr_package_get_size_installed(cr_Package *package);

void cr_package_set_size_installed(cr_Package *package, gint64 value);

gint64 cr_package_get_size_archive(cr_Package *package);

void cr_package_set_size_archive(cr_Package *package, gint64 value);

cr_PackageLoadingFlags cr_package_get_loading_flags(cr_Package *package);

void cr_package_set_loading_flags(cr_Package *package, cr_PackageLoadingFlags flags);

gboolean cr_package_get_skip_dump(cr_Package *package);

void cr_package_set_skip_dump(cr_Package *package, gboolean skip_dump);

GSList *cr_package_get_requires(cr_Package *package);

void cr_package_set_requires(cr_Package *package, GSList *list);

GSList *cr_package_get_provides(cr_Package *package);

void cr_package_set_provides(cr_Package *package, GSList *list);

GSList *cr_package_get_conflicts(cr_Package *package);

void cr_package_set_conflicts(cr_Package *package, GSList *list);

GSList *cr_package_get_obsoletes(cr_Package *package);

void cr_package_set_obsoletes(cr_Package *package, GSList *list);

GSList *cr_package_get_suggests(cr_Package *package);

void cr_package_set_suggests(cr_Package *package, GSList *list);

GSList *cr_package_get_enhances(cr_Package *package);

void cr_package_set_enhances(cr_Package *package, GSList *list);

GSList *cr_package_get_recommends(cr_Package *package);

void cr_package_set_recommends(cr_Package *package, GSList *list);

GSList *cr_package_get_supplements(cr_Package *package);

void cr_package_set_supplements(cr_Package *package, GSList *list);

GSList *cr_package_get_files(cr_Package *package);

void cr_package_set_files(cr_Package *package, GSList *list);

GSList *cr_package_get_changelogs(cr_Package *package);

void cr_package_set_changelogs(cr_Package *package, GSList *list);

GSList *cr_package_get_signatures(cr_Package *package);

cr_BinaryData *cr_package_get_siggpg(cr_Package *package);

void cr_package_set_siggpg(cr_Package *package, cr_BinaryData *data);

cr_BinaryData *cr_package_get_sigpgp(cr_Package *package);

void cr_package_set_sigpgp(cr_Package *package, cr_BinaryData *data);

GStringChunk *cr_package_get_chunk(cr_Package *package);

void cr_package_set_chunk(cr_Package *package, GStringChunk *chunk);

 
#ifdef __cplusplus
}
#endif
 
#endif /* __C_CREATEREPOLIB_PACKAGE_H__ */